home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / demos / VisualAge for Java 2.0 Entry / setup / data1.cab / ide-e / IDE / cache / 14S072B (.txt) < prev    next >
Encoding:
Java Class File  |  1998-09-16  |  22.1 KB  |  989 lines
  1. package com.sun.java.swing;
  2.  
  3. import com.sun.java.accessibility.Accessible;
  4. import com.sun.java.accessibility.AccessibleComponent;
  5. import com.sun.java.accessibility.AccessibleContext;
  6. import com.sun.java.accessibility.AccessibleSelection;
  7. import com.sun.java.accessibility.AccessibleState;
  8. import com.sun.java.accessibility.AccessibleStateSet;
  9. import java.applet.Applet;
  10. import java.awt.AWTEvent;
  11. import java.awt.Component;
  12. import java.awt.Container;
  13. import java.awt.Dialog;
  14. import java.awt.FontMetrics;
  15. import java.awt.Frame;
  16. import java.awt.Graphics;
  17. import java.awt.Point;
  18. import java.awt.Rectangle;
  19. import java.awt.Window;
  20. import java.awt.event.InputEvent;
  21. import java.awt.event.MouseEvent;
  22. import java.lang.reflect.InvocationTargetException;
  23. import java.lang.reflect.Method;
  24. import java.util.Vector;
  25.  
  26. public class SwingUtilities implements SwingConstants {
  27.    private static boolean canAccessEventQueue = false;
  28.    private static boolean eventQueueTested = false;
  29.    static boolean is1dot2 = true;
  30.    private static Class eventDispatchThreadClass;
  31.    private static final Object sharedOwnerFrameKey;
  32.    private static final Object dialogsKey;
  33.    static Class class$java$awt$Toolkit;
  34.  
  35.    static {
  36.       try {
  37.          Class var10000 = class$java$awt$Toolkit;
  38.          if (var10000 == null) {
  39.             try {
  40.                var10000 = Class.forName("java.awt.Toolkit");
  41.             } catch (ClassNotFoundException var1) {
  42.                throw new NoClassDefFoundError(((Throwable)var1).getMessage());
  43.             }
  44.  
  45.             class$java$awt$Toolkit = var10000;
  46.          }
  47.  
  48.          Method m = var10000.getMethod("getMaximumCursorColors", (Class[])null);
  49.          is1dot2 = m != null;
  50.       } catch (NoSuchMethodException var2) {
  51.          is1dot2 = false;
  52.       }
  53.  
  54.       eventDispatchThreadClass = null;
  55.       sharedOwnerFrameKey = new StringBuffer("SwingUtilities.sharedOwnerFrame");
  56.       dialogsKey = new StringBuffer("SwingUtilities.dialogs");
  57.    }
  58.  
  59.    static Object appContextGet(Object key) {
  60.       AppContext ac = AppContext.getAppContext();
  61.       return ac.get(key);
  62.    }
  63.  
  64.    static void appContextPut(Object key, Object value) {
  65.       AppContext ac = AppContext.getAppContext();
  66.       ac.put(key, value);
  67.    }
  68.  
  69.    static void appContextRemove(Object key) {
  70.       AppContext.getAppContext().remove(key);
  71.    }
  72.  
  73.    static final void beginPrivileged() {
  74.    }
  75.  
  76.    public static Rectangle[] computeDifference(Rectangle rectA, Rectangle rectB) {
  77.       if (rectB != null && rectA.intersects(rectB) && !isRectangleContainingRectangle(rectB, rectA)) {
  78.          Rectangle t = new Rectangle();
  79.          Rectangle a = null;
  80.          Rectangle b = null;
  81.          Rectangle c = null;
  82.          Rectangle d = null;
  83.          int rectCount = 0;
  84.          if (isRectangleContainingRectangle(rectA, rectB)) {
  85.             t.x = rectA.x;
  86.             t.y = rectA.y;
  87.             t.width = rectB.x - rectA.x;
  88.             t.height = rectA.height;
  89.             if (t.width > 0 && t.height > 0) {
  90.                a = new Rectangle(t);
  91.                ++rectCount;
  92.             }
  93.  
  94.             t.x = rectB.x;
  95.             t.y = rectA.y;
  96.             t.width = rectB.width;
  97.             t.height = rectB.y - rectA.y;
  98.             if (t.width > 0 && t.height > 0) {
  99.                b = new Rectangle(t);
  100.                ++rectCount;
  101.             }
  102.  
  103.             t.x = rectB.x;
  104.             t.y = rectB.y + rectB.height;
  105.             t.width = rectB.width;
  106.             t.height = rectA.y + rectA.height - (rectB.y + rectB.height);
  107.             if (t.width > 0 && t.height > 0) {
  108.                c = new Rectangle(t);
  109.                ++rectCount;
  110.             }
  111.  
  112.             t.x = rectB.x + rectB.width;
  113.             t.y = rectA.y;
  114.             t.width = rectA.x + rectA.width - (rectB.x + rectB.width);
  115.             t.height = rectA.height;
  116.             if (t.width > 0 && t.height > 0) {
  117.                d = new Rectangle(t);
  118.                ++rectCount;
  119.             }
  120.          } else if (rectB.x <= rectA.x && rectB.y <= rectA.y) {
  121.             if (rectB.x + rectB.width > rectA.x + rectA.width) {
  122.                t.x = rectA.x;
  123.                t.y = rectB.y + rectB.height;
  124.                t.width = rectA.width;
  125.                t.height = rectA.y + rectA.height - (rectB.y + rectB.height);
  126.                if (t.width > 0 && t.height > 0) {
  127.                   a = t;
  128.                   ++rectCount;
  129.                }
  130.             } else if (rectB.y + rectB.height > rectA.y + rectA.height) {
  131.                t.setBounds(rectB.x + rectB.width, rectA.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectA.height);
  132.                if (t.width > 0 && t.height > 0) {
  133.                   a = t;
  134.                   ++rectCount;
  135.                }
  136.             } else {
  137.                t.setBounds(rectB.x + rectB.width, rectA.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectB.y + rectB.height - rectA.y);
  138.                if (t.width > 0 && t.height > 0) {
  139.                   a = new Rectangle(t);
  140.                   ++rectCount;
  141.                }
  142.  
  143.                t.setBounds(rectA.x, rectB.y + rectB.height, rectA.width, rectA.y + rectA.height - (rectB.y + rectB.height));
  144.                if (t.width > 0 && t.height > 0) {
  145.                   b = new Rectangle(t);
  146.                   ++rectCount;
  147.                }
  148.             }
  149.          } else if (rectB.x <= rectA.x && rectB.y + rectB.height >= rectA.y + rectA.height) {
  150.             if (rectB.x + rectB.width > rectA.x + rectA.width) {
  151.                t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  152.                if (t.width > 0 && t.height > 0) {
  153.                   a = t;
  154.                   ++rectCount;
  155.                }
  156.             } else {
  157.                t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  158.                if (t.width > 0 && t.height > 0) {
  159.                   a = new Rectangle(t);
  160.                   ++rectCount;
  161.                }
  162.  
  163.                t.setBounds(rectB.x + rectB.width, rectB.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectA.y + rectA.height - rectB.y);
  164.                if (t.width > 0 && t.height > 0) {
  165.                   b = new Rectangle(t);
  166.                   ++rectCount;
  167.                }
  168.             }
  169.          } else if (rectB.x <= rectA.x) {
  170.             if (rectB.x + rectB.width >= rectA.x + rectA.width) {
  171.                t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  172.                if (t.width > 0 && t.height > 0) {
  173.                   a = new Rectangle(t);
  174.                   ++rectCount;
  175.                }
  176.  
  177.                t.setBounds(rectA.x, rectB.y + rectB.height, rectA.width, rectA.y + rectA.height - (rectB.y + rectB.height));
  178.                if (t.width > 0 && t.height > 0) {
  179.                   b = new Rectangle(t);
  180.                   ++rectCount;
  181.                }
  182.             } else {
  183.                t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  184.                if (t.width > 0 && t.height > 0) {
  185.                   a = new Rectangle(t);
  186.                   ++rectCount;
  187.                }
  188.  
  189.                t.setBounds(rectB.x + rectB.width, rectB.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectB.height);
  190.                if (t.width > 0 && t.height > 0) {
  191.                   b = new Rectangle(t);
  192.                   ++rectCount;
  193.                }
  194.  
  195.                t.setBounds(rectA.x, rectB.y + rectB.height, rectA.width, rectA.y + rectA.height - (rectB.y + rectB.height));
  196.                if (t.width > 0 && t.height > 0) {
  197.                   c = new Rectangle(t);
  198.                   ++rectCount;
  199.                }
  200.             }
  201.          } else if (rectB.x <= rectA.x + rectA.width && rectB.x + rectB.width > rectA.x + rectA.width) {
  202.             if (rectB.y <= rectA.y && rectB.y + rectB.height > rectA.y + rectA.height) {
  203.                t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  204.                if (t.width > 0 && t.height > 0) {
  205.                   a = t;
  206.                   ++rectCount;
  207.                }
  208.             } else if (rectB.y <= rectA.y) {
  209.                t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectB.y + rectB.height - rectA.y);
  210.                if (t.width > 0 && t.height > 0) {
  211.                   a = new Rectangle(t);
  212.                   ++rectCount;
  213.                }
  214.  
  215.                t.setBounds(rectA.x, rectB.y + rectB.height, rectA.width, rectA.y + rectA.height - (rectB.y + rectB.height));
  216.                if (t.width > 0 && t.height > 0) {
  217.                   b = new Rectangle(t);
  218.                   ++rectCount;
  219.                }
  220.             } else if (rectB.y + rectB.height > rectA.y + rectA.height) {
  221.                t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  222.                if (t.width > 0 && t.height > 0) {
  223.                   a = new Rectangle(t);
  224.                   ++rectCount;
  225.                }
  226.  
  227.                t.setBounds(rectA.x, rectB.y, rectB.x - rectA.x, rectA.y + rectA.height - rectB.y);
  228.                if (t.width > 0 && t.height > 0) {
  229.                   b = new Rectangle(t);
  230.                   ++rectCount;
  231.                }
  232.             } else {
  233.                t.setBounds(rectA.x, rectA.y, rectA.width, rectB.y - rectA.y);
  234.                if (t.width > 0 && t.height > 0) {
  235.                   a = new Rectangle(t);
  236.                   ++rectCount;
  237.                }
  238.  
  239.                t.setBounds(rectA.x, rectB.y, rectB.x - rectA.x, rectB.height);
  240.                if (t.width > 0 && t.height > 0) {
  241.                   b = new Rectangle(t);
  242.                   ++rectCount;
  243.                }
  244.  
  245.                t.setBounds(rectA.x, rectB.y + rectB.height, rectA.width, rectA.y + rectA.height - (rectB.y + rectB.height));
  246.                if (t.width > 0 && t.height > 0) {
  247.                   c = new Rectangle(t);
  248.                   ++rectCount;
  249.                }
  250.             }
  251.          } else if (rectB.x >= rectA.x && rectB.x + rectB.width <= rectA.x + rectA.width) {
  252.             if (rectB.y <= rectA.y && rectB.y + rectB.height > rectA.y + rectA.height) {
  253.                t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  254.                if (t.width > 0 && t.height > 0) {
  255.                   a = new Rectangle(t);
  256.                   ++rectCount;
  257.                }
  258.  
  259.                t.setBounds(rectB.x + rectB.width, rectA.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectA.height);
  260.                if (t.width > 0 && t.height > 0) {
  261.                   b = new Rectangle(t);
  262.                   ++rectCount;
  263.                }
  264.             } else if (rectB.y <= rectA.y) {
  265.                t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  266.                if (t.width > 0 && t.height > 0) {
  267.                   a = new Rectangle(t);
  268.                   ++rectCount;
  269.                }
  270.  
  271.                t.setBounds(rectB.x, rectB.y + rectB.height, rectB.width, rectA.y + rectA.height - (rectB.y + rectB.height));
  272.                if (t.width > 0 && t.height > 0) {
  273.                   b = new Rectangle(t);
  274.                   ++rectCount;
  275.                }
  276.  
  277.                t.setBounds(rectB.x + rectB.width, rectA.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectA.height);
  278.                if (t.width > 0 && t.height > 0) {
  279.                   c = new Rectangle(t);
  280.                   ++rectCount;
  281.                }
  282.             } else {
  283.                t.setBounds(rectA.x, rectA.y, rectB.x - rectA.x, rectA.height);
  284.                if (t.width > 0 && t.height > 0) {
  285.                   a = new Rectangle(t);
  286.                   ++rectCount;
  287.                }
  288.  
  289.                t.setBounds(rectB.x, rectA.y, rectB.width, rectB.y - rectA.y);
  290.                if (t.width > 0 && t.height > 0) {
  291.                   b = new Rectangle(t);
  292.                   ++rectCount;
  293.                }
  294.  
  295.                t.setBounds(rectB.x + rectB.width, rectA.y, rectA.x + rectA.width - (rectB.x + rectB.width), rectA.height);
  296.                if (t.width > 0 && t.height > 0) {
  297.                   c = new Rectangle(t);
  298.                   ++rectCount;
  299.                }
  300.             }
  301.          }
  302.  
  303.          Rectangle[] result = new Rectangle[rectCount];
  304.          rectCount = 0;
  305.          if (a != null) {
  306.             result[rectCount++] = a;
  307.          }
  308.  
  309.          if (b != null) {
  310.             result[rectCount++] = b;
  311.          }
  312.  
  313.          if (c != null) {
  314.             result[rectCount++] = c;
  315.          }
  316.  
  317.          if (d != null) {
  318.             result[rectCount++] = d;
  319.          }
  320.  
  321.          return result;
  322.       } else {
  323.          return new Rectangle[0];
  324.       }
  325.    }
  326.  
  327.    public static Rectangle computeIntersection(int x, int y, int width, int height, Rectangle dest) {
  328.       int x1 = x > dest.x ? x : dest.x;
  329.       int x2 = x + width < dest.x + dest.width ? x + width : dest.x + dest.width;
  330.       int y1 = y > dest.y ? y : dest.y;
  331.       int y2 = y + height < dest.y + dest.height ? y + height : dest.y + dest.height;
  332.       dest.x = x1;
  333.       dest.y = y1;
  334.       dest.width = x2 - x1;
  335.       dest.height = y2 - y1;
  336.       return dest;
  337.    }
  338.  
  339.    public static int computeStringWidth(FontMetrics fm, String str) {
  340.       int[] w = fm.getWidths();
  341.       int result = 0;
  342.       int i = 0;
  343.  
  344.       for(int c = str.length(); i < c; ++i) {
  345.          char ch = str.charAt(i);
  346.          if (ch > 255) {
  347.             return fm.stringWidth(str);
  348.          }
  349.  
  350.          result += w[ch];
  351.       }
  352.  
  353.       return result;
  354.    }
  355.  
  356.    public static Rectangle computeUnion(int x, int y, int width, int height, Rectangle dest) {
  357.       int x1 = x < dest.x ? x : dest.x;
  358.       int x2 = x + width > dest.x + dest.width ? x + width : dest.x + dest.width;
  359.       int y1 = y < dest.y ? y : dest.y;
  360.       int y2 = y + height > dest.y + dest.height ? y + height : dest.y + dest.height;
  361.       dest.x = x1;
  362.       dest.y = y1;
  363.       dest.width = x2 - x1;
  364.       dest.height = y2 - y1;
  365.       return dest;
  366.    }
  367.  
  368.    public static MouseEvent convertMouseEvent(Component source, MouseEvent sourceEvent, Component destination) {
  369.       Point p = convertPoint(source, new Point(sourceEvent.getX(), sourceEvent.getY()), destination);
  370.       Component newSource;
  371.       if (destination != null) {
  372.          newSource = destination;
  373.       } else {
  374.          newSource = source;
  375.       }
  376.  
  377.       return new MouseEvent(newSource, ((AWTEvent)sourceEvent).getID(), ((InputEvent)sourceEvent).getWhen(), ((InputEvent)sourceEvent).getModifiers(), p.x, p.y, sourceEvent.getClickCount(), sourceEvent.isPopupTrigger());
  378.    }
  379.  
  380.    public static Point convertPoint(Component source, int x, int y, Component destination) {
  381.       Point point = new Point(x, y);
  382.       return convertPoint(source, point, destination);
  383.    }
  384.  
  385.    public static Point convertPoint(Component source, Point aPoint, Component destination) {
  386.       if (source == null && destination == null) {
  387.          return aPoint;
  388.       } else {
  389.          if (source == null) {
  390.             source = getWindowAncestor(destination);
  391.             if (source == null) {
  392.                throw new Error("Source component not connected to component tree hierarchy");
  393.             }
  394.          }
  395.  
  396.          Point p = new Point(aPoint);
  397.          convertPointToScreen(p, source);
  398.          if (destination == null) {
  399.             destination = getWindowAncestor(source);
  400.             if (destination == null) {
  401.                throw new Error("Destination component not connected to component tree hierarchy");
  402.             }
  403.          }
  404.  
  405.          convertPointFromScreen(p, destination);
  406.          return p;
  407.       }
  408.    }
  409.  
  410.    public static void convertPointFromScreen(Point p, Component c) {
  411.       while(true) {
  412.          int x;
  413.          int y;
  414.          if (c instanceof JComponent) {
  415.             x = ((JComponent)c).getX();
  416.             y = ((JComponent)c).getY();
  417.          } else if (c instanceof Applet) {
  418.             Point pp = c.getLocationOnScreen();
  419.             x = pp.x;
  420.             y = pp.y;
  421.          } else {
  422.             Rectangle b = c.getBounds();
  423.             x = b.x;
  424.             y = b.y;
  425.          }
  426.  
  427.          p.x -= x;
  428.          p.y -= y;
  429.          if (!(c instanceof Window) && !(c instanceof Applet)) {
  430.             c = c.getParent();
  431.             if (c != null) {
  432.                continue;
  433.             }
  434.          }
  435.  
  436.          return;
  437.       }
  438.    }
  439.  
  440.    public static void convertPointToScreen(Point p, Component c) {
  441.       while(true) {
  442.          int x;
  443.          int y;
  444.          if (c instanceof JComponent) {
  445.             x = ((JComponent)c).getX();
  446.             y = ((JComponent)c).getY();
  447.          } else if (c instanceof Applet) {
  448.             Point pp = c.getLocationOnScreen();
  449.             x = pp.x;
  450.             y = pp.y;
  451.          } else {
  452.             Rectangle b = c.getBounds();
  453.             x = b.x;
  454.             y = b.y;
  455.          }
  456.  
  457.          p.x += x;
  458.          p.y += y;
  459.          if (!(c instanceof Window) && !(c instanceof Applet)) {
  460.             c = c.getParent();
  461.             if (c != null) {
  462.                continue;
  463.             }
  464.          }
  465.  
  466.          return;
  467.       }
  468.    }
  469.  
  470.    public static Rectangle convertRectangle(Component source, Rectangle aRectangle, Component destination) {
  471.       Point point = new Point(aRectangle.x, aRectangle.y);
  472.       point = convertPoint(source, point, destination);
  473.       return new Rectangle(point.x, point.y, aRectangle.width, aRectangle.height);
  474.    }
  475.  
  476.    static final void endPrivileged() {
  477.    }
  478.  
  479.    public static Component findFocusOwner(Component c) {
  480.       if (c instanceof Window) {
  481.          return ((Window)c).getFocusOwner();
  482.       } else if (c instanceof JComponent && ((JComponent)c).hasFocus()) {
  483.          return c;
  484.       } else if (!(c instanceof Container)) {
  485.          return null;
  486.       } else {
  487.          int n = ((Container)c).countComponents();
  488.  
  489.          for(int i = 0; i < n; ++i) {
  490.             Component focusOwner = findFocusOwner(((Container)c).getComponent(i));
  491.             if (focusOwner != null) {
  492.                return focusOwner;
  493.             }
  494.          }
  495.  
  496.          return null;
  497.       }
  498.    }
  499.  
  500.    public static Accessible getAccessibleAt(Component c, Point p) {
  501.       if (c instanceof Accessible) {
  502.          Accessible a = (Accessible)c;
  503.          if (a != null) {
  504.             AccessibleContext ac = a.getAccessibleContext();
  505.             if (ac != null) {
  506.                int nchildren = ac.getAccessibleChildrenCount();
  507.  
  508.                for(int i = 0; i < nchildren; ++i) {
  509.                   a = ac.getAccessibleChild(i);
  510.                   if (a != null) {
  511.                      ac = a.getAccessibleContext();
  512.                      if (ac != null) {
  513.                         AccessibleComponent ncomponents = ac.getAccessibleComponent();
  514.                         if (ncomponents != null && ncomponents.isShowing()) {
  515.                            Point var13 = ncomponents.getLocation();
  516.                            Point np = new Point(p.x - var13.x, p.y - var13.y);
  517.                            if (ncomponents.contains(np)) {
  518.                               return a;
  519.                            }
  520.                         }
  521.                      }
  522.                   }
  523.                }
  524.             }
  525.          }
  526.  
  527.          return (Accessible)c;
  528.       } else {
  529.          Component ret = c;
  530.          if (!c.contains(p.x, p.y)) {
  531.             ret = null;
  532.          } else if (c instanceof Container) {
  533.             Container cnt = (Container)c;
  534.             int ncomponents = cnt.getComponentCount();
  535.  
  536.             for(int i = 0; i < ncomponents; ++i) {
  537.                Component comp = cnt.getComponent(i);
  538.                if (comp != null && comp.isShowing()) {
  539.                   Point location = comp.getLocation();
  540.                   if (comp.contains(p.x - location.x, p.y - location.y)) {
  541.                      ret = comp;
  542.                   }
  543.                }
  544.             }
  545.          }
  546.  
  547.          return ret instanceof Accessible ? (Accessible)ret : null;
  548.       }
  549.    }
  550.  
  551.    public static Accessible getAccessibleChild(Component c, int i) {
  552.       if (c instanceof Container) {
  553.          Component[] children = ((Container)c).getComponents();
  554.          int count = 0;
  555.  
  556.          for(int j = 0; j < children.length; ++j) {
  557.             if (children[j] instanceof Accessible) {
  558.                if (count == i) {
  559.                   return (Accessible)children[j];
  560.                }
  561.  
  562.                ++count;
  563.             }
  564.          }
  565.       }
  566.  
  567.       return null;
  568.    }
  569.  
  570.    public static int getAccessibleChildrenCount(Component c) {
  571.       int count = 0;
  572.       if (c instanceof Container) {
  573.          Component[] children = ((Container)c).getComponents();
  574.  
  575.          for(int i = 0; i < children.length; ++i) {
  576.             if (children[i] instanceof Accessible) {
  577.                ++count;
  578.             }
  579.          }
  580.       }
  581.  
  582.       return count;
  583.    }
  584.  
  585.    public static int getAccessibleIndexInParent(Component c) {
  586.       int index = -1;
  587.       Container parent = c.getParent();
  588.       if (parent != null) {
  589.          Component[] ca = parent.getComponents();
  590.  
  591.          for(int i = 0; i < ca.length; ++i) {
  592.             if (ca[i] instanceof Accessible) {
  593.                ++index;
  594.             }
  595.  
  596.             if (c.equals(ca[i])) {
  597.                return index;
  598.             }
  599.          }
  600.       }
  601.  
  602.       return -1;
  603.    }
  604.  
  605.    public static AccessibleStateSet getAccessibleStateSet(Component c) {
  606.       AccessibleStateSet states = new AccessibleStateSet();
  607.       if (c.isEnabled()) {
  608.          states.add(AccessibleState.ENABLED);
  609.       }
  610.  
  611.       if (c.isFocusTraversable()) {
  612.          states.add(AccessibleState.FOCUSABLE);
  613.       }
  614.  
  615.       if (c.isVisible()) {
  616.          states.add(AccessibleState.VISIBLE);
  617.       }
  618.  
  619.       if (c.isShowing()) {
  620.          states.add(AccessibleState.SHOWING);
  621.       }
  622.  
  623.       for(Container p = c.getParent(); p != null; p = ((Component)p).getParent()) {
  624.          if (p instanceof Window && ((Window)p).getFocusOwner() == c) {
  625.             states.add(AccessibleState.FOCUSED);
  626.          }
  627.       }
  628.  
  629.       if (c instanceof Accessible) {
  630.          AccessibleContext ac = ((Accessible)c).getAccessibleContext();
  631.          if (ac != null) {
  632.             Accessible ap = ac.getAccessibleParent();
  633.             if (ap != null) {
  634.                AccessibleContext pac = ap.getAccessibleContext();
  635.                if (pac != null) {
  636.                   AccessibleSelection as = pac.getAccessibleSelection();
  637.                   if (as != null) {
  638.                      states.add(AccessibleState.SELECTABLE);
  639.                      int i = ac.getAccessibleIndexInParent();
  640.                      if (i >= 0 && as.isAccessibleChildSelected(i)) {
  641.                         states.add(AccessibleState.SELECTED);
  642.                      }
  643.                   }
  644.                }
  645.             }
  646.          }
  647.       }
  648.  
  649.       if (c instanceof JComponent && ((JComponent)c).isOpaque()) {
  650.          states.add(AccessibleState.OPAQUE);
  651.       }
  652.  
  653.       return states;
  654.    }
  655.  
  656.    public static Container getAncestorNamed(String name, Component comp) {
  657.       if (comp != null && name != null) {
  658.          Container parent;
  659.          for(parent = comp.getParent(); parent != null && !name.equals(((Component)parent).getName()); parent = ((Component)parent).getParent()) {
  660.          }
  661.  
  662.          return parent;
  663.       } else {
  664.          return null;
  665.       }
  666.    }
  667.  
  668.    public static Container getAncestorOfClass(Class c, Component comp) {
  669.       if (comp != null && c != null) {
  670.          Container parent;
  671.          for(parent = comp.getParent(); parent != null && !c.isInstance(parent); parent = ((Component)parent).getParent()) {
  672.          }
  673.  
  674.          return parent;
  675.       } else {
  676.          return null;
  677.       }
  678.    }
  679.  
  680.    private static CellRendererPane getCellRendererPane(Component c, Container p) {
  681.       Container shell = c.getParent();
  682.       if (shell instanceof CellRendererPane) {
  683.          if (((Component)shell).getParent() != p) {
  684.             p.add(shell);
  685.          }
  686.       } else {
  687.          shell = new CellRendererPane();
  688.          shell.add(c);
  689.          p.add(shell);
  690.       }
  691.  
  692.       return (CellRendererPane)shell;
  693.    }
  694.  
  695.    public static Component getDeepestComponentAt(Component parent, int x, int y) {
  696.       if (parent != null && parent instanceof Container) {
  697.          Component child = ((Container)parent).getComponentAt(x, y);
  698.          if (child != null && child != parent && child.isVisible()) {
  699.             Rectangle b = child.getBounds();
  700.             child = getDeepestComponentAt(child, x - b.x, y - b.y);
  701.             if (child != null) {
  702.                return child;
  703.             }
  704.          }
  705.       }
  706.  
  707.       return parent;
  708.    }
  709.  
  710.    public static Rectangle getLocalBounds(Component aComponent) {
  711.       Rectangle b = new Rectangle(aComponent.getBounds());
  712.       b.x = b.y = 0;
  713.       return b;
  714.    }
  715.  
  716.    static JDialog getRecycledModalDialog(Frame frame, String title) {
  717.       Vector dialogs = (Vector)appContextGet(dialogsKey);
  718.       if (dialogs == null) {
  719.          dialogs = new Vector();
  720.          appContextPut(dialogsKey, dialogs);
  721.       }
  722.  
  723.       JDialog dialog = null;
  724.       synchronized(dialogs) {
  725.          for(int i = 0; i < dialogs.size(); ++i) {
  726.             dialog = (JDialog)dialogs.elementAt(i);
  727.             if (((Component)dialog).getParent() == frame) {
  728.                dialogs.removeElement(dialog);
  729.                ((Dialog)dialog).setTitle(title);
  730.                return dialog;
  731.             }
  732.          }
  733.  
  734.          dialog = new JDialog(frame, title, true);
  735.       }
  736.  
  737.       return dialog;
  738.    }
  739.  
  740.    public static JRootPane getRootPane(Component c) {
  741.       for(Container cnt = c.getParent(); cnt != null; cnt = ((Component)cnt).getParent()) {
  742.          if (cnt instanceof JRootPane) {
  743.             return (JRootPane)cnt;
  744.          }
  745.       }
  746.  
  747.       return null;
  748.    }
  749.  
  750.    static Frame getSharedOwnerFrame() {
  751.       Frame sharedOwnerFrame = (Frame)appContextGet(sharedOwnerFrameKey);
  752.       if (sharedOwnerFrame == null) {
  753.          sharedOwnerFrame = new 1();
  754.          appContextPut(sharedOwnerFrameKey, sharedOwnerFrame);
  755.       }
  756.  
  757.       return sharedOwnerFrame;
  758.    }
  759.  
  760.    private static Window getWindowAncestor(Component c) {
  761.       for(Container parent = c.getParent(); c != null; parent = ((Component)parent).getParent()) {
  762.          if (parent instanceof Window) {
  763.             return (Window)parent;
  764.          }
  765.       }
  766.  
  767.       return null;
  768.    }
  769.  
  770.    public static void invokeAndWait(Runnable doRun) throws InterruptedException, InvocationTargetException {
  771.       if (isEventDispatchThread()) {
  772.          throw new Error("Cannot call invokeAndWait from the event dispatcher thread");
  773.       } else {
  774.          Object lock = new 2(doRun);
  775.          Exception exc = null;
  776.          synchronized(lock){}
  777.  
  778.          try {
  779.             exc = SystemEventQueueUtilities.postRunnable(doRun, lock);
  780.             lock.wait();
  781.          } catch (Throwable var5) {
  782.             throw var5;
  783.          }
  784.  
  785.          if (exc != null) {
  786.             throw new InvocationTargetException(exc);
  787.          }
  788.       }
  789.    }
  790.  
  791.    public static void invokeLater(Runnable doRun) {
  792.       SystemEventQueueUtilities.postRunnable(doRun, (Object)null);
  793.    }
  794.  
  795.    public static boolean isDescendingFrom(Component a, Component b) {
  796.       if (a == b) {
  797.          return true;
  798.       } else {
  799.          for(Container p = a.getParent(); p != null; p = ((Component)p).getParent()) {
  800.             if (p == b) {
  801.                return true;
  802.             }
  803.          }
  804.  
  805.          return false;
  806.       }
  807.    }
  808.  
  809.    public static boolean isEventDispatchThread() {
  810.       Thread currentThread = Thread.currentThread();
  811.       if (eventDispatchThreadClass == null) {
  812.          Class currentThreadClass = currentThread.getClass();
  813.          if (currentThreadClass.getName().indexOf("EventDispatchThread") < 0 && currentThreadClass.getName().indexOf("JMEventQueue") < 0) {
  814.             return false;
  815.          } else {
  816.             eventDispatchThreadClass = currentThreadClass;
  817.             return true;
  818.          }
  819.       } else {
  820.          return eventDispatchThreadClass.isInstance(currentThread);
  821.       }
  822.    }
  823.  
  824.    public static boolean isLeftMouseButton(MouseEvent anEvent) {
  825.       return (((InputEvent)anEvent).getModifiers() & 16) == 16 || ((InputEvent)anEvent).getModifiers() == 0;
  826.    }
  827.  
  828.    public static boolean isMiddleMouseButton(MouseEvent anEvent) {
  829.       return (((InputEvent)anEvent).getModifiers() & 8) == 8;
  830.    }
  831.  
  832.    public static final boolean isRectangleContainingRectangle(Rectangle a, Rectangle b) {
  833.       return b.x >= a.x && b.x + b.width <= a.x + a.width && b.y >= a.y && b.y + b.height <= a.y + a.height;
  834.    }
  835.  
  836.    public static boolean isRightMouseButton(MouseEvent anEvent) {
  837.       return (((InputEvent)anEvent).getModifiers() & 4) == 4;
  838.    }
  839.  
  840.    public static String layoutCompoundLabel(FontMetrics fm, String text, Icon icon, int verticalAlignment, int horizontalAlignment, int verticalTextPosition, int horizontalTextPosition, Rectangle viewR, Rectangle iconR, Rectangle textR, int textIconGap) {
  841.       if (icon != null) {
  842.          iconR.width = icon.getIconWidth();
  843.          iconR.height = icon.getIconHeight();
  844.       } else {
  845.          iconR.width = iconR.height = 0;
  846.       }
  847.  
  848.       boolean textIsEmpty = text == null || text.equals("");
  849.       if (textIsEmpty) {
  850.          textR.width = textR.height = 0;
  851.          text = "";
  852.       } else {
  853.          textR.width = computeStringWidth(fm, text);
  854.          textR.height = fm.getHeight();
  855.       }
  856.  
  857.       int gap = !textIsEmpty && icon != null ? textIconGap : 0;
  858.       if (!textIsEmpty) {
  859.          int availTextWidth;
  860.          if (horizontalTextPosition == 0) {
  861.             availTextWidth = viewR.width;
  862.          } else {
  863.             availTextWidth = viewR.width - (iconR.width + gap);
  864.          }
  865.  
  866.          if (textR.width > availTextWidth) {
  867.             String clipString = "...";
  868.             int totalWidth = computeStringWidth(fm, clipString);
  869.  
  870.             int nChars;
  871.             for(nChars = 0; nChars < text.length(); ++nChars) {
  872.                totalWidth += fm.charWidth(text.charAt(nChars));
  873.                if (totalWidth > availTextWidth) {
  874.                   break;
  875.                }
  876.             }
  877.  
  878.             text = text.substring(0, nChars) + clipString;
  879.             textR.width = computeStringWidth(fm, text);
  880.          }
  881.       }
  882.  
  883.       if (verticalTextPosition == 1) {
  884.          if (horizontalTextPosition != 0) {
  885.             textR.y = 0;
  886.          } else {
  887.             textR.y = -(textR.height + gap);
  888.          }
  889.       } else if (verticalTextPosition == 0) {
  890.          textR.y = iconR.height / 2 - textR.height / 2;
  891.       } else if (horizontalTextPosition != 0) {
  892.          textR.y = iconR.height - textR.height;
  893.       } else {
  894.          textR.y = iconR.height + gap;
  895.       }
  896.  
  897.       if (horizontalTextPosition == 2) {
  898.          textR.x = -(textR.width + gap);
  899.       } else if (horizontalTextPosition == 0) {
  900.          textR.x = iconR.width / 2 - textR.width / 2;
  901.       } else {
  902.          textR.x = iconR.width + gap;
  903.       }
  904.  
  905.       Rectangle labelR = iconR.union(textR);
  906.       int var19;
  907.       if (verticalAlignment == 1) {
  908.          var19 = viewR.y - labelR.y;
  909.       } else if (verticalAlignment == 0) {
  910.          var19 = viewR.y + viewR.height / 2 - (labelR.y + labelR.height / 2);
  911.       } else {
  912.          var19 = viewR.y + viewR.height - (labelR.y + labelR.height);
  913.       }
  914.  
  915.       int dx;
  916.       if (horizontalAlignment == 2) {
  917.          dx = viewR.x - labelR.x;
  918.       } else if (horizontalAlignment == 0) {
  919.          dx = viewR.x + viewR.width / 2 - (labelR.x + labelR.width / 2);
  920.       } else {
  921.          dx = viewR.x + viewR.width - (labelR.x + labelR.width);
  922.       }
  923.  
  924.       textR.x += dx;
  925.       textR.y += var19;
  926.       iconR.x += dx;
  927.       iconR.y += var19;
  928.       return text;
  929.    }
  930.  
  931.    public static void paintComponent(Graphics g, Component c, Container p, int x, int y, int w, int h) {
  932.       getCellRendererPane(c, p).paintComponent(g, c, p, x, y, w, h, false);
  933.    }
  934.  
  935.    public static void paintComponent(Graphics g, Component c, Container p, Rectangle r) {
  936.       paintComponent(g, c, p, r.x, r.y, r.width, r.height);
  937.    }
  938.  
  939.    static void recycleModalDialog(JDialog dialog) {
  940.       Vector dialogs = (Vector)appContextGet(dialogsKey);
  941.       synchronized(dialogs){}
  942.  
  943.       try {
  944.          dialog.getContentPane().removeAll();
  945.          dialogs.addElement(dialog);
  946.       } catch (Throwable var4) {
  947.          throw var4;
  948.       }
  949.  
  950.    }
  951.  
  952.    public static void updateComponentTreeUI(Component c) {
  953.       updateComponentTreeUI0(c);
  954.       c.invalidate();
  955.       c.validate();
  956.       c.repaint();
  957.    }
  958.  
  959.    private static void updateComponentTreeUI0(Component c) {
  960.       if (c instanceof JComponent) {
  961.          ((JComponent)c).updateUI();
  962.       }
  963.  
  964.       Component[] children = null;
  965.       if (c instanceof JMenu) {
  966.          children = ((JMenu)c).getMenuComponents();
  967.       } else if (c instanceof Container) {
  968.          children = ((Container)c).getComponents();
  969.       }
  970.  
  971.       if (children != null) {
  972.          for(int i = 0; i < children.length; ++i) {
  973.             updateComponentTreeUI0(children[i]);
  974.          }
  975.       }
  976.  
  977.    }
  978.  
  979.    public static Window windowForComponent(Component aComponent) {
  980.       for(Container p = aComponent.getParent(); p != null; p = ((Component)p).getParent()) {
  981.          if (p instanceof Window) {
  982.             return (Window)p;
  983.          }
  984.       }
  985.  
  986.       return null;
  987.    }
  988. }
  989.